// 导入路由
const router = require('express').Router()

const { query } = require('express');
// 导入考试数据模型并获取User类实例
const User = require('../model/userModel');
const userModel = new User();

// 导入jwt模块
const Jwt = require('../common/token/index')



// 注册接口
// 接口地址:/api/user/register
// 方式:POST
// 参数: nickName,account,password,email
// 说明:nickName:用户名,account:账号,password: 密码,email:邮箱
// 响应格式:json
// 示例:http://127.0.0.1:4000/api/user/register
router.post('/register', async (req, res) => {
    // 接收前端提交的表单信息
    let { nickName, account, password, email } = req.body;
    if (nickName == undefined || account == undefined || password == undefined || email == undefined) {
        res({
            code: 404,
            msg: "缺少信息,请填写完整",
        })
    }
    else {
        await userModel.register(nickName, account, password, email)
            .then(
                content => {
                    // 把注册的结果响应给前端
                    res.send(content);
                },
                err => {
                    res.send(err);
                }
            )
    }
})

// 登录接口
// 接口地址:/api/user/login
// 方式:POST
// 参数:account,password
// 说明:account:账号,password:密码
// 响应格式:JSON
// 示例:http://127.0.0.1:4000/api/user/login
router.post('/login', async (req, res) => {
    let { account, password } = req.body;
    if (account == undefined || password == undefined) {
        res.send({
            code: 404,
            msg: "缺少信息"
        })
    }
    else {
        await userModel.login(account, password)
            .then(
                content => {
                    let id = content.id;
                    let token = new Jwt(id).getToken();
                    if (content.code == 200) {
                        res.send({
                            code: content.code,
                            msg: content.msg,
                            token
                        })
                    }
                    else {
                        res.send(res)
                    }
                }
            )
            .catch(
                err => {
                    res.send(err)
                }
            )
    }

})

// 登录接口(管理员)
// 地址： /api/user/signin
// 方式： POST
// 参数： account, password,role
// 响应数据格式： json格式
// 示例： http://localhost:4000/api/user/signin
router.post('/signin', async (req,res)=> {
    let { account, password , role} = req.body;
    console.log({ account, password , role});
    if(account == undefined || password == undefined || role == undefined) {
         // 缺少值
         res.send({
            code: -1,
            msg: "缺少参数登录，请重新提交"
        })
    }
    else {
        // 调用用户类登录方法
        userModel.signin(account, password,role)
        .then(
            data=>{
                // 把登录的结果响应给前端
                // 处理token（用户临时身份）
                let id = data.id;
                let token = new Jwt(id).getToken();
                if(data.code == 200) {
                    // 登录成功才有token
                    res.send({
                        code: data.code,
                        msg: data.msg,
                        nickName: data.nickName,
                        token 
                    });
                }
                else {
                    // 登录失败
                    res.send(data);
                }
            },
            err=> {
                // 发生了错误
                res.send(err);
            }
        )
    }
})


// 删除账号接口
// 接口地址:/api/user/remove
// 方式:POST
// 参数:token
// 说明:token 临时身份,登录后能拿到
// 响应格式:JSON
// 示例:http://127.0.0.1:4000/api/user/remove
router.post('/remove', async (req, res) => {
    // 获取用户临时身份
    let token = req.body.token || req.headers.token;
    if (token) {
        let result = new Jwt(token).verifyToken();
        if (result.code == 200) {
            let id = result.info.data;
            userModel.remove(id)
                .then(
                    content => {
                        res.send(content)
                    },
                    err => {
                        res.send(err)
                    }
                )
        }
        else {
            res.send({
                coed: -1,
                msg: "登录失效，请重新登录"
            })
        }
    }
    else {
        res.send({
            code: -1,
            msg: '缺少参数'
        })
    }
})

// 设置用户头像接口
// 接口地址:/api/user/img
// 方式:POST
// 参数:token,imgUrl
// 说明:token 临时身份,登录后能拿到 imgUrl:图片路径
// 响应格式:JSON
// 示例:http://127.0.0.1:4000/api/user/img
router.post('/img', async (req, res) => {
    let token = req.body.token || req.headers.token;
    let imgUrl = req.body.imgUrl;
    if (token && imgUrl) {
        let result = new Jwt(token).verifyToken();
        if (result.code == 200) {
            let id = result.info.data;
            await userModel.img(id, imgUrl)
                .then(
                    content => {
                        res.send(content)
                    },
                    err => {
                        res.send(err)
                    }
                )
        }
    }
    else {
        res.send({
            code: -1,
            msg: '却少参数'
        })
    }
})

// 设置用户信息接口
// 接口地址:/api/user/edit
// 方式:POST
// 参数:token,birthday,sex,address,phone
// 说明:token 临时身份
// 响应格式:JSON
// 示例:http://127.0.0.1:4000/api/user/edit
router.post('/edit', async (req, res) => {
    let token = req.body.token || req.headers.token;
    let { age, sex, address, phone } = req.body;
    if (token) {
        let result = new Jwt(token).verifyToken();
        if (result.code == 200) {
            let id = result.info.data;
            await userModel.edit(id, age, sex, address, phone)
                .then(
                    content => {
                        res.send(content)
                    },
                    err => {
                        res.send(err)
                    }
                )
        }
        else{
            res.send({
                code:-1,
                msg:"登录失效"
            })
        }
    }
    else {
        res.send({
            code: -1,
            msg: '却少参数'
        })
    }
})

// 获取用户信息接口
// 接口地址:/api/user/info
// 方式:GET
// 参数:token,
// 说明:token 临时身份
// 响应格式:JSON
// 示例:http://127.0.0.1:4000/api/user/info?token=xxx
router.get('/info',async(req,res)=>{
    let token = req.query.token;
    if(token){
        let result = new Jwt(token).verifyToken();
        if(result.code==200){
            let id = result.info.data;
            await userModel.info(id)
            .then(
                content=>{
                    res.send(content)
                },
                err=>{
                    res.send(err)
                }
            )
        }else{
            res.send({
                code:-1,
                msg:"token出错s"
            })
        }
    }
    else{
        res.send({
            code:-1,
            msg:"缺少参数token"
        })
    }
})

// 获取用户列表接口
// 地址： /api/user/list
// 方式： GET
// 参数： page, pageSize
// 响应数据格式： json格式
// 示例： http://localhost:4000/api/user/list?page=1&pageSize=10
router.get('/list', async (req,res)=> {
    let {page, pageSize} = req.query;
    if(page == undefined || pageSize == undefined) {
        res.send({
            code: -1,
            msg: "缺少参数"
        })
    }
    else {
        await userModel.list(page, pageSize)
        .then(
            content=> {
                // 把获取的结果响应给前端
                res.send(content)
            },
            err=> {
                // 把失败的结果响应给前端
                res.send(err)
            }
        )
    }
})

// 获取所有用户
// 地址： /api/user/listAll
// 方式： GET
// 参数： 无
// 响应数据格式： json格式
// 示例： http://localhost:4000/api/user/listAll
router.get('/listAll',async(req,res)=>{
    await userModel.listAll().then(
        rows=>{
            res.send(rows)
        },
        err=>{
            res.send(err)
        }
    )
})

// 设置用户密码接口（找回密码）
// 接口地址:/api/user/pwd
// 方式:POST
// 参数:account,password
// 说明:
// 响应格式:JSON
// 示例:http://127.0.0.1:4000/api/user/pwd
router.post('/pwd', async (req, res) => {
    let account = req.body.account 
    let password = req.body.password;
    if (account && password) {
        await userModel.pwd(account,password)
        .then(
            content=>{
                res.send(content)
            },
            err=>{
                res.send(err)
            }
        )
    }
    else {
        res.send({
            code: -1,
            msg: '却少参数'
        })
    }
})

// 判断用户是否登录在线
// 接口地址:/api/user/logged
// 方式:POST
// 参数:token
// 说明:
// 响应格式:JSON
// 示例:http://127.0.0.1:4000/api/user/logged
router.post('/logged', async (req, res) => {
    let token = req.body.token||req.headers.token;
    if(token){
        let result = new Jwt(token).verifyToken();
        if(result.code==200){
            res.send({
                code:200,
                msg:"用户处于在线状态"
            })
        }
        else{
            res.send({
                code:-1,
                msg:"登录失效，请重新登录"
            })
        }
    }
    else{
        res.send({
            code:-1,
            msg:"缺少参数"
        })
    }
})




// 把当前路由挂在系统对象上
module.exports = router